home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / pyshared / DistUpgrade / DistUpgradeCache.py < prev    next >
Encoding:
Python Source  |  2009-11-02  |  47.1 KB  |  1,102 lines
  1. # DistUpgradeCache.py 
  2. #  
  3. #  Copyright (c) 2004-2008 Canonical
  4. #  
  5. #  Author: Michael Vogt <michael.vogt@ubuntu.com>
  6. # 
  7. #  This program is free software; you can redistribute it and/or 
  8. #  modify it under the terms of the GNU General Public License as 
  9. #  published by the Free Software Foundation; either version 2 of the
  10. #  License, or (at your option) any later version.
  11. # 
  12. #  This program is distributed in the hope that it will be useful,
  13. #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. #  GNU General Public License for more details.
  16. # 
  17. #  You should have received a copy of the GNU General Public License
  18. #  along with this program; if not, write to the Free Software
  19. #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20. #  USA
  21.  
  22. import warnings
  23. warnings.filterwarnings("ignore", "apt API not stable yet", FutureWarning)
  24. import apt
  25. import apt_pkg
  26. import os
  27. import os.path
  28. import re
  29. import logging
  30. import string
  31. import statvfs
  32. import time
  33. import gettext
  34. import datetime
  35. import threading
  36. import ConfigParser
  37. from subprocess import Popen, PIPE
  38.  
  39. from DistUpgradeGettext import gettext as _
  40. from DistUpgradeGettext import ngettext
  41. from DistUpgradeConfigParser import DistUpgradeConfig
  42. from DistUpgradeView import FuzzyTimeToStr
  43.  
  44. class CacheException(Exception):
  45.     pass
  46. class CacheExceptionLockingFailed(CacheException):
  47.     pass
  48. class CacheExceptionDpkgInterrupted(CacheException):
  49.     pass
  50.  
  51. # the initrd/vmlinuz/abi space required in /boot for each kernel
  52. KERNEL_INITRD_SIZE = 15*1024*1024
  53.  
  54. class FreeSpaceRequired(object):
  55.     """ FreeSpaceRequired object:
  56.     
  57.     This exposes:
  58.     - the total size required (size_total)
  59.     - the dir that requires the space (dir)
  60.     - the additional space that is needed (size_needed)
  61.     """
  62.     def __init__(self, size_total, dir, size_needed):
  63.         self.size_total = size_total
  64.         self.dir = dir
  65.         self.size_needed = size_needed
  66.     def __str__(self):
  67.         return "FreeSpaceRequired Object: Dir: %s size_total: %s size_needed: %s" % (self.dir, self.size_total, self.size_needed)
  68.     
  69.  
  70. class NotEnoughFreeSpaceError(CacheException):
  71.     """ 
  72.     Exception if there is not enough free space for this operation 
  73.     
  74.     """
  75.     def __init__(self, free_space_required_list):
  76.         self.free_space_required_list = free_space_required_list
  77.  
  78. class MyCache(apt.Cache):
  79.     ReInstReq = 1
  80.     HoldReInstReq = 3
  81.  
  82.     # init
  83.     def __init__(self, config, view, quirks, progress=None, lock=True):
  84.         apt.Cache.__init__(self, progress)
  85.         self.to_install = []
  86.         self.to_remove = []
  87.         self.view = view
  88.         self.quirks = quirks
  89.         self.lock = False
  90.         self.partialUpgrade = False
  91.         self.config = config
  92.         self.metapkgs = self.config.getlist("Distro","MetaPkgs")
  93.         # acquire lock
  94.         self._listsLock = -1
  95.         if lock:
  96.             try:
  97.                 apt_pkg.PkgSystemLock()
  98.                 self.lockListsDir()
  99.                 self.lock = True
  100.             except SystemError, e:
  101.                 # checking for this is ok, its not translatable
  102.                 if "dpkg --configure -a" in str(e):
  103.                     raise CacheExceptionDpkgInterrupted, e
  104.                 raise CacheExceptionLockingFailed, e
  105.         # a list of regexp that are not allowed to be removed
  106.         self.removal_blacklist = config.getListFromFile("Distro","RemovalBlacklistFile")
  107.         self.uname = Popen(["uname","-r"],stdout=PIPE).communicate()[0].strip()
  108.         self._initAptLog()
  109.         # from hardy on we use recommends by default, so for the 
  110.         # transition to the new dist we need to enable them now
  111.         if (config.get("Sources","From") == "hardy" and 
  112.             not "RELEASE_UPGRADE_NO_RECOMMENDS" in os.environ):
  113.             apt_pkg.Config.Set("APT::Install-Recommends","true")
  114.  
  115.     @property
  116.     def reqReinstallPkgs(self):
  117.         " return the packages not downloadable packages in reqreinst state "
  118.         reqreinst = set()
  119.         for pkg in self:
  120.             if (not pkg.candidateDownloadable and 
  121.                 (pkg._pkg.InstState == self.ReInstReq or
  122.                  pkg._pkg.InstState == self.HoldReInstReq)):
  123.                 reqreinst.add(pkg.name)
  124.         return reqreinst
  125.  
  126.     def fixReqReinst(self, view):
  127.         " check for reqreinst state and offer to fix it "
  128.         reqreinst = self.reqReinstallPkgs
  129.         if len(reqreinst) > 0:
  130.             header = ngettext("Remove package in bad state",
  131.                               "Remove packages in bad state", 
  132.                               len(reqreinst))
  133.             summary = ngettext("The package '%s' is in an inconsistent "
  134.                                "state and needs to be reinstalled, but "
  135.                                "no archive can be found for it. "
  136.                                "Do you want to remove this package "
  137.                                "now to continue?",
  138.                                "The packages '%s' are in an inconsistent "
  139.                                "state and need to be reinstalled, but "
  140.                                "no archives can be found for them. Do you "
  141.                                "want to remove these packages now to "
  142.                                "continue?",
  143.                                len(reqreinst)) % ", ".join(reqreinst)
  144.             if view.askYesNoQuestion(header, summary):
  145.                 self.releaseLock()
  146.                 cmd = ["dpkg","--remove","--force-remove-reinstreq"] + list(reqreinst)
  147.                 view.getTerminal().call(cmd)
  148.                 self.getLock()
  149.                 return True
  150.         return False
  151.  
  152.     # logging stuff
  153.     def _initAptLog(self):
  154.         " init logging, create log file"
  155.         logdir = self.config.getWithDefault("Files","LogDir",
  156.                                             "/var/log/dist-upgrade")
  157.         if not os.path.exists(logdir):
  158.             os.makedirs(logdir)
  159.         apt_pkg.Config.Set("Dir::Log",logdir)
  160.         apt_pkg.Config.Set("Dir::Log::Terminal","apt-term.log")
  161.         self.logfd = os.open(os.path.join(logdir,"apt.log"),
  162.                              os.O_RDWR|os.O_CREAT|os.O_APPEND|os.O_SYNC, 0644)
  163.         os.write(self.logfd, "Log time: %s\n" % datetime.datetime.now())
  164.         # turn on debugging in the cache
  165.         apt_pkg.Config.Set("Debug::pkgProblemResolver","true")
  166.         apt_pkg.Config.Set("Debug::pkgDepCache::AutoInstall","true")
  167.     def _startAptResolverLog(self):
  168.         if hasattr(self, "old_stdout"):
  169.             os.close(self.old_stdout)
  170.             os.close(self.old_stderr)
  171.         self.old_stdout = os.dup(1)
  172.         self.old_stderr = os.dup(2)
  173.         os.dup2(self.logfd, 1)
  174.         os.dup2(self.logfd, 2)
  175.     def _stopAptResolverLog(self):
  176.         os.fsync(1)
  177.         os.fsync(2)
  178.         os.dup2(self.old_stdout, 1)
  179.         os.dup2(self.old_stderr, 2)
  180.     # use this decorator instead of the _start/_stop stuff directly
  181.     # FIXME: this should probably be a decorator class where all
  182.     #        logging is moved into?
  183.     def withResolverLog(f):
  184.         " decorator to ensure that the apt output is logged "
  185.         def wrapper(*args, **kwargs):
  186.             args[0]._startAptResolverLog()
  187.             res = f(*args, **kwargs)
  188.             args[0]._stopAptResolverLog()
  189.             return res
  190.         return wrapper
  191.  
  192.     # properties
  193.     @property
  194.     def requiredDownload(self):
  195.         """ get the size of the packages that are required to download """
  196.         pm = apt_pkg.GetPackageManager(self._depcache)
  197.         fetcher = apt_pkg.GetAcquire()
  198.         pm.GetArchives(fetcher, self._list, self._records)
  199.         return fetcher.FetchNeeded
  200.     @property
  201.     def additionalRequiredSpace(self):
  202.         """ get the size of the additional required space on the fs """
  203.         return self._depcache.UsrSize
  204.     @property
  205.     def isBroken(self):
  206.         """ is the cache broken """
  207.         return self._depcache.BrokenCount > 0
  208.  
  209.     # methods
  210.     def lockListsDir(self):
  211.         name = apt_pkg.Config.FindDir("Dir::State::Lists") + "lock"
  212.         self._listsLock = apt_pkg.GetLock(name)
  213.         if self._listsLock < 0:
  214.             e = "Can not lock '%s' " % name
  215.             raise CacheExceptionLockingFailed, e
  216.     def unlockListsDir(self):
  217.         if self._listsLock > 0:
  218.             os.close(self._listsLock)
  219.             self._listsLock = -1
  220.     def update(self, fprogress=None):
  221.         """
  222.         our own update implementation is required because we keep the lists
  223.         dir lock
  224.         """
  225.         self.unlockListsDir()
  226.         res = apt.Cache.update(self, fprogress)
  227.         self.lockListsDir()
  228.         if fprogress.release_file_download_error:
  229.             # FIXME: not ideal error message, but we just reuse a 
  230.             #        existing one here to avoid a new string
  231.             raise IOError(_("The server may be overloaded"))
  232.         if res == False:
  233.             raise IOError("apt.cache.update() returned False, but did not raise exception?!?")
  234.  
  235.     def commit(self, fprogress, iprogress):
  236.         logging.info("cache.commit()")
  237.         if self.lock:
  238.             self.releaseLock()
  239.         apt.Cache.commit(self, fprogress, iprogress)
  240.  
  241.     def releaseLock(self, pkgSystemOnly=True):
  242.         if self.lock:
  243.             try:
  244.                 apt_pkg.PkgSystemUnLock()
  245.                 self.lock = False
  246.             except SystemError, e:
  247.                 logging.debug("failed to SystemUnLock() (%s) " % e)
  248.  
  249.     def getLock(self, pkgSystemOnly=True):
  250.         if not self.lock:
  251.             try:
  252.                 apt_pkg.PkgSystemLock()
  253.                 self.lock = True
  254.             except SystemError, e:
  255.                 logging.debug("failed to SystemLock() (%s) " % e)
  256.  
  257.     def downloadable(self, pkg, useCandidate=True):
  258.         " check if the given pkg can be downloaded "
  259.         if useCandidate:
  260.             ver = self._depcache.GetCandidateVer(pkg._pkg)
  261.         else:
  262.             ver = pkg._pkg.CurrentVer
  263.         if ver == None:
  264.             logging.warning("no version information for '%s' (useCandidate=%s)" % (pkg.name, useCandidate))
  265.             return False
  266.         return ver.Downloadable
  267.     
  268.     def fixBroken(self):
  269.         """ try to fix broken dependencies on the system, may throw
  270.             SystemError when it can't"""
  271.         return self._depcache.FixBroken()
  272.  
  273.     def create_snapshot(self):
  274.         """ create a snapshot of the current changes """
  275.         self.to_install = []
  276.         self.to_remove = []
  277.         for pkg in self.getChanges():
  278.             if pkg.markedInstall or pkg.markedUpgrade:
  279.                 self.to_install.append(pkg.name)
  280.             if pkg.markedDelete:
  281.                 self.to_remove.append(pkg.name)
  282.  
  283.     def clear(self):
  284.         self._depcache.Init()
  285.  
  286.     def restore_snapshot(self):
  287.         """ restore a snapshot """
  288.         actiongroup = apt_pkg.GetPkgActionGroup(self._depcache)
  289.         self.clear()
  290.         for name in self.to_remove:
  291.             pkg = self[name]
  292.             pkg.markDelete()
  293.         for name in self.to_install:
  294.             pkg = self[name]
  295.             pkg.markInstall(autoFix=False, autoInst=False)
  296.  
  297.     def needServerMode(self):
  298.         """ 
  299.         This checks if we run on a desktop or a server install.
  300.         
  301.         A server install has more freedoms, for a desktop install
  302.         we force a desktop meta package to be install on the upgrade.
  303.  
  304.         We look for a installed desktop meta pkg and for key 
  305.         dependencies, if none of those are installed we assume
  306.         server mode
  307.         """
  308.         #logging.debug("needServerMode() run")
  309.         # check for the MetaPkgs (e.g. ubuntu-desktop)
  310.         metapkgs = self.config.getlist("Distro","MetaPkgs")
  311.         for key in metapkgs:
  312.             # if it is installed we are done
  313.             if self.has_key(key) and self[key].isInstalled:
  314.                 logging.debug("needServerMode(): run in 'desktop' mode, (because of pkg '%s')" % key)
  315.                 return False
  316.             # if it is not installed, but its key depends are installed 
  317.             # we are done too (we auto-select the package later)
  318.             deps_found = True
  319.             for pkg in self.config.getlist(key,"KeyDependencies"):
  320.                 deps_found &= self.has_key(pkg) and self[pkg].isInstalled
  321.             if deps_found:
  322.                 logging.debug("needServerMode(): run in 'desktop' mode, (because of key deps for '%s')" % key)
  323.                 return False
  324.         logging.debug("needServerMode(): can not find a desktop meta package or key deps, running in server mode")
  325.         return True
  326.  
  327.     def sanityCheck(self, view):
  328.         """ check if the cache is ok and if the required metapkgs
  329.             are installed
  330.         """
  331.         if self.isBroken:
  332.             try:
  333.                 logging.debug("Have broken pkgs, trying to fix them")
  334.                 self.fixBroken()
  335.             except SystemError:
  336.                 view.error(_("Broken packages"),
  337.                                  _("Your system contains broken packages "
  338.                                    "that couldn't be fixed with this "
  339.                                    "software. "
  340.                                    "Please fix them first using synaptic or "
  341.                                    "apt-get before proceeding."))
  342.                 return False
  343.         return True
  344.  
  345.     def markInstall(self, pkg, reason=""):
  346.         logging.debug("Installing '%s' (%s)" % (pkg, reason))
  347.         if self.has_key(pkg):
  348.             self[pkg].markInstall()
  349.             if not (self[pkg].markedInstall or self[pkg].markedUpgrade):
  350.                 logging.error("Installing/upgrading '%s' failed" % pkg)
  351.                 #raise (SystemError, "Installing '%s' failed" % pkg)
  352.                 return False
  353.         return True
  354.     def markUpgrade(self, pkg, reason=""):
  355.         logging.debug("Upgrading '%s' (%s)" % (pkg, reason))
  356.         if self.has_key(pkg) and self[pkg].isInstalled:
  357.             self[pkg].markUpgrade()
  358.             if not self[pkg].markedUpgrade:
  359.                 logging.error("Upgrading '%s' failed" % pkg)
  360.                 return False
  361.         return True
  362.     def markRemove(self, pkg, reason=""):
  363.         logging.debug("Removing '%s' (%s)" % (pkg, reason))
  364.         if self.has_key(pkg):
  365.             self[pkg].markDelete()
  366.     def markPurge(self, pkg, reason=""):
  367.         logging.debug("Purging '%s' (%s)" % (pkg, reason))
  368.         if self.has_key(pkg):
  369.             self._depcache.MarkDelete(self[pkg]._pkg,True)
  370.  
  371.     def _keepInstalled(self, pkgname, reason):
  372.         if (self.has_key(pkgname)
  373.             and self[pkgname].isInstalled
  374.             and self[pkgname].markedDelete):
  375.             self.markInstall(pkgname, reason)
  376.  
  377.     def keepInstalledRule(self):
  378.         """ run after the dist-upgrade to ensure that certain
  379.             packages are kept installed """
  380.         # first the global list
  381.         for pkgname in self.config.getlist("Distro","KeepInstalledPkgs"):
  382.             self._keepInstalled(pkgname, "Distro KeepInstalledPkgs rule")
  383.         # the the per-metapkg rules
  384.         for key in self.metapkgs:
  385.             if self.has_key(key) and (self[key].isInstalled or
  386.                                       self[key].markedInstall):
  387.                 for pkgname in self.config.getlist(key,"KeepInstalledPkgs"):
  388.                     self._keepInstalled(pkgname, "%s KeepInstalledPkgs rule" % key)
  389.  
  390.         # only enforce section if we have a network. Otherwise we run
  391.         # into CD upgrade issues for installed language packs etc
  392.         if self.config.get("Options","withNetwork") == "True":
  393.             logging.debug("Running KeepInstalledSection rules")
  394.             # now the KeepInstalledSection code
  395.             for section in self.config.getlist("Distro","KeepInstalledSection"):
  396.                 for pkg in self:
  397.                     if pkg.markedDelete and pkg.section == section:
  398.                         self._keepInstalled(pkg.name, "Distro KeepInstalledSection rule: %s" % section)
  399.             for key in self.metapkgs:
  400.                 if self.has_key(key) and (self[key].isInstalled or
  401.                                           self[key].markedInstall):
  402.                     for section in self.config.getlist(key,"KeepInstalledSection"):
  403.                         for pkg in self:
  404.                             if pkg.markedDelete and pkg.section == section:
  405.                                 self._keepInstalled(pkg.name, "%s KeepInstalledSection rule: %s" % (key, section))
  406.         
  407.  
  408.     def postUpgradeRule(self):
  409.         " run after the upgrade was done in the cache "
  410.         for (rule, action) in [("Install", self.markInstall),
  411.                                ("Upgrade", self.markUpgrade),
  412.                                ("Remove", self.markRemove),
  413.                                ("Purge", self.markPurge)]:
  414.             # first the global list
  415.             for pkg in self.config.getlist("Distro","PostUpgrade%s" % rule):
  416.                 action(pkg, "Distro PostUpgrade%s rule" % rule)
  417.             for key in self.metapkgs:
  418.                 if self.has_key(key) and (self[key].isInstalled or
  419.                                           self[key].markedInstall):
  420.                     for pkg in self.config.getlist(key,"PostUpgrade%s" % rule):
  421.                         action(pkg, "%s PostUpgrade%s rule" % (key, rule))
  422.         # run the quirks handlers
  423.         if not self.partialUpgrade:
  424.             self.quirks.run("PostDistUpgradeCache")
  425.  
  426.     def identifyObsoleteKernels(self):
  427.         # we have a funny policy that we remove security updates
  428.         # for the kernel from the archive again when a new ABI
  429.         # version hits the archive. this means that we have
  430.         # e.g. 
  431.         # linux-image-2.6.24-15-generic 
  432.         # is obsolete when 
  433.         # linux-image-2.6.24-19-generic
  434.         # is available
  435.         # ...
  436.         # This code tries to identify the kernels that can be removed
  437.         logging.debug("identifyObsoleteKernels()")
  438.         obsolete_kernels = set()
  439.         version = self.config.get("KernelRemoval","Version")
  440.         basenames = self.config.getlist("KernelRemoval","BaseNames")
  441.         types = self.config.getlist("KernelRemoval","Types")
  442.         for pkg in self:
  443.             for base in basenames:
  444.                 basename = "%s-%s-" % (base,version)
  445.                 for type in types:
  446.                     if (pkg.name.startswith(basename) and 
  447.                         pkg.name.endswith(type) and
  448.                         pkg.isInstalled):
  449.                         if (pkg.name == "%s-%s" % (base,self.uname)):
  450.                             logging.debug("skipping running kernel %s" % pkg.name)
  451.                             continue
  452.                         logging.debug("removing obsolete kernel '%s'" % pkg.name)
  453.                         obsolete_kernels.add(pkg.name)
  454.         logging.debug("identifyObsoleteKernels found '%s'" % obsolete_kernels)
  455.         return obsolete_kernels
  456.  
  457.     def checkForNvidia(self):
  458.         """ 
  459.         this checks for nvidia hardware and checks what driver is needed
  460.         """
  461.         logging.debug("nvidiaUpdate()")
  462.         # if the free drivers would give us a equally hard time, we would
  463.         # never be able to release
  464.         try:
  465.             from NvidiaDetector.nvidiadetector import NvidiaDetection
  466.         except ImportError, e:
  467.             logging.error("NvidiaDetector can not be imported %s" % e)
  468.             return False
  469.         try:
  470.             # get new detection module and use the modalises files
  471.             # from within the release-upgrader
  472.             nv = NvidiaDetection(datadir="./modaliases/")
  473.             #nv = NvidiaDetection()
  474.             # check if a binary driver is installed now
  475.             for oldDriver in nv.oldPackages:
  476.                 if self.has_key(oldDriver) and self[oldDriver].isInstalled:
  477.                     self.markRemove(oldDriver, "old nvidia driver")
  478.                     break
  479.             else:
  480.                 logging.info("no old nvidia driver installed, installing no new")
  481.                 return False
  482.             # check which one to use
  483.             driver = nv.selectDriver()
  484.             logging.debug("nv.selectDriver() returned '%s'" % driver)
  485.             if not self.has_key(driver):
  486.                 logging.warning("no '%s' found" % driver)
  487.                 return False
  488.             if not (self[driver].markedInstall or self[driver].markedUpgrade):
  489.                 self[driver].markInstall()
  490.                 logging.info("installing %s as suggested by NvidiaDetector" % driver)
  491.                 return True
  492.         except Exception, e:
  493.             logging.error("NvidiaDetection returned a error: %s" % e)
  494.         return False
  495.  
  496.  
  497.     def getKernelsFromBaseInstaller(self):
  498.         """get the list of recommended kernels from base-installer"""
  499.         kernels = Popen(["/bin/sh", "./get_kernel_list.sh"],
  500.                         stdout=PIPE).communicate()[0]
  501.         kernels = filter(lambda x : len(x) > 0,
  502.                          map(string.strip, kernels.split("\n")))
  503.         logging.debug("./get_kernel_list.sh returns: %s" % kernels)
  504.         return kernels
  505.  
  506.     def _selectKernelFromBaseInstaller(self):
  507.         """ use the get_kernel_list.sh script (that uses base-installer)
  508.             to figure out what kernel is most suitable for the system
  509.         """
  510.         # check if we have a kernel from that list installed first
  511.         kernels = self.getKernelsFromBaseInstaller()
  512.         for kernel in kernels:
  513.             if not self.has_key(kernel):
  514.                 logging.debug("%s not available in cache" % kernel)
  515.                 continue
  516.             # check if installed
  517.             if self[kernel].isInstalled:
  518.                 logging.debug("%s kernel already installed" % kernel)
  519.                 if self[kernel].isUpgradable and not self[kernel].markedUpgrade:
  520.                     self.markUpgrade(kernel, "Upgrading kernel from base-installer")
  521.                 return 
  522.         # if we have not found a kernel yet, use the first one that installs
  523.         for kernel in kernels:
  524.             if self.markInstall(kernel, "Selecting new kernel from base-installer"):
  525.                 return
  526.  
  527.     def checkForKernel(self):
  528.         """ check for the running kernel and try to ensure that we have
  529.             an updated version
  530.         """
  531.         logging.debug("Kernel uname: '%s' " % self.uname)
  532.         try:
  533.             (version, build, flavour) = self.uname.split("-")
  534.         except Exception, e:
  535.             logging.warning("Can't parse kernel uname: '%s' (self compiled?)" % e)
  536.             return False
  537.         # now check if we have a SMP system
  538.         dmesg = Popen(["dmesg"],stdout=PIPE).communicate()[0]
  539.         if "WARNING: NR_CPUS limit" in dmesg:
  540.             logging.debug("UP kernel on SMP system!?!")
  541.         # use base-installer to get the kernel we want (if it exists)
  542.         if os.path.exists("./get_kernel_list.sh"):
  543.             self._selectKernelFromBaseInstaller()
  544.         else:
  545.             logging.debug("skipping ./get_kernel_list.sh: not found")
  546.         return True
  547.  
  548.     def checkPriority(self):
  549.         # tuple of priorities we require to be installed 
  550.         need = ('required', )
  551.         # stuff that its ok not to have
  552.         removeEssentialOk = self.config.getlist("Distro","RemoveEssentialOk")
  553.         # check now
  554.         for pkg in self:
  555.             # WORKADOUND bug on the CD/python-apt #253255
  556.             ver = pkg._pcache._depcache.GetCandidateVer(pkg._pkg)
  557.             if ver and ver.Priority == 0:
  558.                 logging.error("Package %s has no priority set" % pkg.name)
  559.                 continue
  560.             if (pkg.candidateDownloadable and
  561.                 not (pkg.isInstalled or pkg.markedInstall) and
  562.                 not pkg.name in removeEssentialOk and
  563.                 pkg.priority in need):
  564.                 self.markInstall(pkg.name, "priority in required set '%s' but not scheduled for install" % need)
  565.  
  566.     # FIXME: make this a decorator (just like the withResolverLog())
  567.     def updateGUI(self, view, lock):
  568.         while lock.locked():
  569.             view.processEvents()
  570.             time.sleep(0.01)
  571.  
  572.     @withResolverLog
  573.     def distUpgrade(self, view, serverMode, partialUpgrade):
  574.         # keep the GUI alive
  575.         lock = threading.Lock()
  576.         lock.acquire()
  577.         t = threading.Thread(target=self.updateGUI, args=(self.view, lock,))
  578.         t.start()
  579.         try:
  580.             # upgrade (and make sure this way that the cache is ok)
  581.             self.upgrade(True)
  582.  
  583.             # check that everything in priority required is installed
  584.             self.checkPriority()
  585.  
  586.             # see if our KeepInstalled rules are honored
  587.             self.keepInstalledRule()
  588.  
  589.             # check if we got a new kernel
  590.             self.checkForKernel()
  591.  
  592.             # check for nvidia stuff
  593.             self.checkForNvidia()
  594.  
  595.             # and if we have some special rules
  596.             self.postUpgradeRule()
  597.  
  598.             # install missing meta-packages (if not in server upgrade mode)
  599.             self._keepBaseMetaPkgsInstalled(view)
  600.             if not serverMode:
  601.                 # if this fails, a system error is raised
  602.                 self._installMetaPkgs(view)
  603.  
  604.             # see if it all makes sense, if not this function raises 
  605.             self._verifyChanges()
  606.  
  607.         except SystemError, e:
  608.             # this should go into a finally: line, see below for the 
  609.             # rationale why it doesn't 
  610.             lock.release()
  611.             t.join()
  612.             # FIXME: change the text to something more useful
  613.             details =  _("An unresolvable problem occurred while "
  614.                          "calculating the upgrade:\n%s\n\n "
  615.                          "This can be caused by:\n"
  616.                          " * Upgrading to a pre-release version of Ubuntu\n"
  617.                          " * Running the current pre-release version of Ubuntu\n"
  618.                          " * Unofficial software packages not provided by Ubuntu\n"
  619.                          "\n" % e)
  620.             # we never have partialUpgrades (including removes) on a stable system
  621.             # with only ubuntu sources so we do not recommend reporting a bug
  622.             if partialUpgrade:
  623.                 details += _("This is most likely a transient problem, "
  624.                              "please try again later.")
  625.             else:
  626.                 details += _("If none of this applies, then please report this bug against "
  627.                              "the 'update-manager' package and include the files in "
  628.                              "/var/log/dist-upgrade/ in the bug report.")
  629.             # make the error text available again on stdout for the 
  630.             # text frontend
  631.             self._stopAptResolverLog()
  632.             view.error(_("Could not calculate the upgrade"), details)
  633.             # start the resolver log again because this is run with
  634.             # the withResolverLog decorator
  635.             self._startAptResolverLog()            
  636.             logging.error("Dist-upgrade failed: '%s'", e)
  637.             return False
  638.         # would be nice to be able to use finally: here, but we need
  639.         # to run on python2.4 too 
  640.         #finally:
  641.         # wait for the gui-update thread to exit
  642.         lock.release()
  643.         t.join()
  644.         
  645.         # check the trust of the packages that are going to change
  646.         untrusted = []
  647.         for pkg in self.getChanges():
  648.             if pkg.markedDelete:
  649.                 continue
  650.             # special case because of a bug in pkg.candidateOrigin
  651.             if pkg.markedDowngrade:
  652.                 for ver in pkg._pkg.VersionList:
  653.                     # version is lower than installed one
  654.                     if apt_pkg.VersionCompare(ver.VerStr, pkg.installedVersion) < 0:
  655.                         for (verFileIter,index) in ver.FileList:
  656.                             indexfile = pkg._list.FindIndex(verFileIter)
  657.                             if indexfile and not indexfile.IsTrusted:
  658.                                 untrusted.append(pkg.name)
  659.                                 break
  660.                 continue
  661.             origins = pkg.candidateOrigin
  662.             trusted = False
  663.             for origin in origins:
  664.                 #print origin
  665.                 trusted |= origin.trusted
  666.             if not trusted:
  667.                 untrusted.append(pkg.name)
  668.         # check if the user overwrote the unauthenticated warning
  669.         try:
  670.             b = self.config.getboolean("Distro","AllowUnauthenticated")
  671.             if b:
  672.                 logging.warning("AllowUnauthenticated set!")
  673.                 return True
  674.         except ConfigParser.NoOptionError, e:
  675.             pass
  676.         if len(untrusted) > 0:
  677.             untrusted.sort()
  678.             logging.error("Unauthenticated packages found: '%s'" % \
  679.                           " ".join(untrusted))
  680.             # FIXME: maybe ask a question here? instead of failing?
  681.             self._stopAptResolverLog()
  682.             view.error(_("Error authenticating some packages"),
  683.                        _("It was not possible to authenticate some "
  684.                          "packages. This may be a transient network problem. "
  685.                          "You may want to try again later. See below for a "
  686.                          "list of unauthenticated packages."),
  687.                        "\n".join(untrusted))
  688.             # start the resolver log again because this is run with
  689.             # the withResolverLog decorator
  690.             self._startAptResolverLog()            
  691.             return False
  692.         return True
  693.  
  694.     def _verifyChanges(self):
  695.         """ this function tests if the current changes don't violate
  696.             our constrains (blacklisted removals etc)
  697.         """
  698.         removeEssentialOk = self.config.getlist("Distro","RemoveEssentialOk")
  699.         # check changes
  700.         for pkg in self.getChanges():
  701.             if pkg.markedDelete and self._inRemovalBlacklist(pkg.name):
  702.                 logging.debug("The package '%s' is marked for removal but it's in the removal blacklist", pkg.name)
  703.                 raise SystemError, _("The package '%s' is marked for removal but it is in the removal blacklist.") % pkg.name
  704.             if pkg.markedDelete and (pkg._pkg.Essential == True and
  705.                                      not pkg.name in removeEssentialOk):
  706.                 logging.debug("The package '%s' is marked for removal but it's a ESSENTIAL package", pkg.name)
  707.                 raise SystemError, _("The essential package '%s' is marked for removal.") % pkg.name
  708.         # check bad-versions blacklist
  709.         badVersions = self.config.getlist("Distro","BadVersions")
  710.         for bv in badVersions:
  711.             (pkgname, ver) = bv.split("_")
  712.             if (self.has_key(pkgname) and
  713.                 self[pkgname].candidateVersion == ver and
  714.                 (self[pkgname].markedInstall or
  715.                  self[pkgname].markedUpgrade)):
  716.                 raise SystemError, _("Trying to install blacklisted version '%s'") % bv
  717.         return True
  718.     
  719.     def _lookupPkgRecord(self, pkg):
  720.         """ 
  721.         helper to make sure that the pkg._records is pointing to the right
  722.         location - needed because python-apt 0.7.9 dropped the python-apt
  723.         version but we can not yet use the new version because on upgrade
  724.         the old version is still installed
  725.         """ 
  726.         ver = pkg._pcache._depcache.GetCandidateVer(pkg._pkg)
  727.         if ver is None:
  728.             print "No candidate ver: ", pkg.name
  729.             return False
  730.         if ver.FileList is None:
  731.             print "No FileList for: %s " % self._pkg.Name()
  732.             return False
  733.         f, index = ver.FileList.pop(0)
  734.         pkg._pcache._records.Lookup((f, index))
  735.         return True
  736.  
  737.     @property
  738.     def installedTasks(self):
  739.         tasks = {}
  740.         installed_tasks = set()
  741.         for pkg in self:
  742.             if not self._lookupPkgRecord(pkg):
  743.                 logging.debug("no PkgRecord found for '%s', skipping " % pkg.name)
  744.                 continue
  745.             for line in pkg._pcache._records.Record.split("\n"):
  746.                 if line.startswith("Task:"):
  747.                     for task in (line[len("Task:"):]).split(","):
  748.                         task = task.strip()
  749.                         if not tasks.has_key(task):
  750.                             tasks[task] = set()
  751.                         tasks[task].add(pkg.name)
  752.         for task in tasks:
  753.             installed = True
  754.             for pkgname in tasks[task]:
  755.                 if not self[pkgname].isInstalled:
  756.                     installed = False
  757.                     break
  758.             if installed:
  759.                 installed_tasks.add(task)
  760.         return installed_tasks
  761.             
  762.     def installTasks(self, tasks):
  763.         logging.debug("running installTasks")
  764.         for pkg in self:
  765.             if pkg.markedInstall or pkg.isInstalled:
  766.                 continue
  767.             self._lookupPkgRecord(pkg)
  768.             if not (hasattr(pkg._pcache._records,"Record") and pkg._pcache._records.Record):
  769.                 logging.warning("can not find Record for '%s'" % pkg.name)
  770.                 continue
  771.             for line in pkg._pcache._records.Record.split("\n"):
  772.                 if line.startswith("Task:"):
  773.                     for task in (line[len("Task:"):]).split(","):
  774.                         task = task.strip()
  775.                         if task in tasks:
  776.                             pkg.markInstall()
  777.         return True
  778.     
  779.     def _keepBaseMetaPkgsInstalled(self, view):
  780.         for pkg in self.config.getlist("Distro","BaseMetaPkgs"):
  781.             self._keepInstalled(pkg, "base meta package keep installed rule")
  782.  
  783.     def _installMetaPkgs(self, view):
  784.  
  785.         def metaPkgInstalled():
  786.             """ 
  787.             internal helper that checks if at least one meta-pkg is 
  788.             installed or marked install
  789.             """
  790.             for key in metapkgs:
  791.                 if self.has_key(key):
  792.                     pkg = self[key]
  793.                     if pkg.isInstalled and pkg.markedDelete:
  794.                         logging.debug("metapkg '%s' installed but markedDelete" % pkg.name)
  795.                     if ((pkg.isInstalled and not pkg.markedDelete) 
  796.                         or self[key].markedInstall):
  797.                         return True
  798.             return False
  799.  
  800.         # now check for ubuntu-desktop, kubuntu-desktop, edubuntu-desktop
  801.         metapkgs = self.config.getlist("Distro","MetaPkgs")
  802.  
  803.         # we never go without ubuntu-base
  804.         for pkg in self.config.getlist("Distro","BaseMetaPkgs"):
  805.             self[pkg].markInstall()
  806.  
  807.         # every meta-pkg that is installed currently, will be marked
  808.         # install (that result in a upgrade and removes a markDelete)
  809.         for key in metapkgs:
  810.             try:
  811.                 if self.has_key(key) and self[key].isInstalled:
  812.                     logging.debug("Marking '%s' for upgrade" % key)
  813.                     self[key].markUpgrade()
  814.             except SystemError, e:
  815.                 logging.debug("Can't mark '%s' for upgrade (%s)" % (key,e))
  816.                 raise SystemError, _("Can not mark '%s' for upgrade") % key
  817.         # check if we have a meta-pkg, if not, try to guess which one to pick
  818.         if not metaPkgInstalled():
  819.             logging.debug("none of the '%s' meta-pkgs installed" % metapkgs)
  820.             for key in metapkgs:
  821.                 deps_found = True
  822.                 for pkg in self.config.getlist(key,"KeyDependencies"):
  823.                     deps_found &= self.has_key(pkg) and self[pkg].isInstalled
  824.                 if deps_found:
  825.                     logging.debug("guessing '%s' as missing meta-pkg" % key)
  826.                     try:
  827.                         self[key].markInstall()
  828.                     except (SystemError, KeyError), e:
  829.                         logging.error("failed to mark '%s' for install (%s)" % (key,e))
  830.                         view.error(_("Can't install '%s'" % key),
  831.                                    _("It was impossible to install a "
  832.                                      "required package. Please report "
  833.                                      "this as a bug. "))
  834.                         return False
  835.                     logging.debug("markedInstall: '%s' -> '%s'" % (key, self[key].markedInstall))
  836.                     break
  837.         # check if we actually found one
  838.         if not metaPkgInstalled():
  839.             # FIXME: provide a list
  840.             view.error(_("Can't guess meta-package"),
  841.                        _("Your system does not contain a "
  842.                          "ubuntu-desktop, kubuntu-desktop, xubuntu-desktop or "
  843.                          "edubuntu-desktop package and it was not "
  844.                          "possible to detect which version of "
  845.                         "Ubuntu you are running.\n "
  846.                          "Please install one of the packages "
  847.                          "above first using synaptic or "
  848.                          "apt-get before proceeding."))
  849.             return False
  850.         return True
  851.  
  852.     def _inRemovalBlacklist(self, pkgname):
  853.         for expr in self.removal_blacklist:
  854.             if re.compile(expr).match(pkgname):
  855.                 return True
  856.         return False
  857.  
  858.     @withResolverLog
  859.     def tryMarkObsoleteForRemoval(self, pkgname, remove_candidates, foreign_pkgs):
  860.         #logging.debug("tryMarkObsoleteForRemoval(): %s" % pkgname)
  861.         # sanity check, first see if it looks like a running kernel pkg
  862.         if pkgname.endswith(self.uname):
  863.             logging.debug("skipping running kernel pkg '%s'" % pkgname)
  864.             return False
  865.         if self._inRemovalBlacklist(pkgname):
  866.             logging.debug("skipping '%s' (in removalBlacklist)" % pkgname)
  867.             return False
  868.         # ensure we honor KeepInstalledSection here as well
  869.         for section in self.config.getlist("Distro","KeepInstalledSection"):
  870.             if self.has_key(pkgname) and self[pkgname].section == section:
  871.                 logging.debug("skipping '%s' (in KeepInstalledSection)" % pkgname)
  872.                 return False
  873.         # if we don't have the package anyway, we are fine (this can
  874.         # happen when forced_obsoletes are specified in the config file)
  875.         if not self.has_key(pkgname):
  876.             #logging.debug("package '%s' not in cache" % pkgname)
  877.             return True
  878.         # check if we want to purge 
  879.         try:
  880.             purge = self.config.getboolean("Distro","PurgeObsoletes")
  881.         except ConfigParser.NoOptionError, e:
  882.             purge = False
  883.  
  884.         # this is a delete candidate, only actually delete,
  885.         # if it dosn't remove other packages depending on it
  886.         # that are not obsolete as well
  887.         actiongroup = apt_pkg.GetPkgActionGroup(self._depcache)
  888.         self.create_snapshot()
  889.         try:
  890.             self[pkgname].markDelete(purge=purge)
  891.             self.view.processEvents()
  892.             #logging.debug("marking '%s' for removal" % pkgname)
  893.             for pkg in self.getChanges():
  894.                 if (pkg.name not in remove_candidates or 
  895.                       pkg.name in foreign_pkgs or 
  896.                       self._inRemovalBlacklist(pkg.name)):
  897.                     logging.debug("package '%s' has unwanted removals, skipping" % pkgname)
  898.                     self.restore_snapshot()
  899.                     return False
  900.         except (SystemError,KeyError),e:
  901.             logging.warning("_tryMarkObsoleteForRemoval failed for '%s' (%s: %s)" % (pkgname, repr(e), e))
  902.             self.restore_snapshot()
  903.             return False
  904.         return True
  905.     
  906.     def _getObsoletesPkgs(self):
  907.         " get all package names that are not downloadable "
  908.         obsolete_pkgs =set()        
  909.         for pkg in self:
  910.             if pkg.isInstalled: 
  911.                 # check if any version is downloadable. we need to check
  912.                 # for older ones too, because there might be
  913.                 # cases where e.g. firefox in gutsy-updates is newer
  914.                 # than hardy
  915.                 if not self.anyVersionDownloadable(pkg):
  916.                     obsolete_pkgs.add(pkg.name)
  917.         return obsolete_pkgs
  918.  
  919.     def anyVersionDownloadable(self, pkg):
  920.         " helper that checks if any of the version of pkg is downloadable "
  921.         for ver in pkg._pkg.VersionList:
  922.             if ver.Downloadable:
  923.                 return True
  924.         return False
  925.  
  926.     def _getUnusedDependencies(self):
  927.         " get all package names that are not downloadable "
  928.         unused_dependencies =set()        
  929.         for pkg in self:
  930.             if pkg.isInstalled and self._depcache.IsGarbage(pkg._pkg):
  931.                 unused_dependencies.add(pkg.name)
  932.         return unused_dependencies
  933.  
  934.     def _getForeignPkgs(self, allowed_origin, fromDist, toDist):
  935.         """ get all packages that are installed from a foreign repo
  936.             (and are actually downloadable)
  937.         """
  938.         foreign_pkgs=set()        
  939.         for pkg in self:
  940.             if pkg.isInstalled and self.downloadable(pkg):
  941.                 # assume it is foreign and see if it is from the 
  942.                 # official archive
  943.                 foreign=True
  944.                 for origin in pkg.candidateOrigin:
  945.                     # FIXME: use some better metric here
  946.                     if fromDist in origin.archive and \
  947.                            origin.origin == allowed_origin:
  948.                         foreign = False
  949.                     if toDist in origin.archive and \
  950.                            origin.origin == allowed_origin:
  951.                         foreign = False
  952.                 if foreign:
  953.                     foreign_pkgs.add(pkg.name)
  954.         return foreign_pkgs
  955.  
  956.     def checkFreeSpace(self):
  957.         """
  958.         this checks if we have enough free space on /var, /boot and /usr
  959.         with the given cache 
  960.  
  961.         Note: this can not be fully accurate if there are multiple 
  962.               mountpoints for /usr, /var, /boot
  963.         """
  964.  
  965.         class FreeSpace(object):
  966.             " helper class that represents the free space on each mounted fs "
  967.             def __init__(self, initialFree):
  968.                 self.free = initialFree
  969.                 self.need = 0
  970.  
  971.         def make_fs_id(d):
  972.             """ return 'id' of a directory so that directories on the
  973.                 same filesystem get the same id (simply the mount_point)
  974.             """
  975.             for mount_point in mounted:
  976.                 if d.startswith(mount_point):
  977.                     return mount_point
  978.             return "/"
  979.  
  980.         # this is all a bit complicated
  981.         # 1) check what is mounted (in mounted)
  982.         # 2) create FreeSpace objects for the dirs we are interested in
  983.         #    (mnt_map)
  984.         # 3) use the  mnt_map to check if we have enough free space and
  985.         #    if not tell the user how much is missing
  986.         mounted = []
  987.         mnt_map = {}
  988.         fs_free = {}
  989.         for line in open("/proc/mounts"):
  990.             try:
  991.                 (what, where, fs, options, a, b) = line.split()
  992.             except ValueError, e:
  993.                 logging.debug("line '%s' in /proc/mounts not understood (%s)" % (line, e))
  994.                 continue
  995.             if not where in mounted:
  996.                 mounted.append(where)
  997.         # make sure mounted is sorted by longest path
  998.         mounted.sort(cmp=lambda a,b: cmp(len(a),len(b)), reverse=True)
  999.         archivedir = apt_pkg.Config.FindDir("Dir::Cache::archives")
  1000.         aufs_rw_dir = "/tmp/"
  1001.         if (hasattr(self, "config") and
  1002.             self.config.getWithDefault("Aufs","Enabled", False)):
  1003.             aufs_rw_dir = self.config.get("Aufs","RWDir")
  1004.             if not os.path.exists(aufs_rw_dir):
  1005.                 os.makedirs(aufs_rw_dir)
  1006.         logging.debug("cache aufs_rw_dir: %s" % aufs_rw_dir)
  1007.         for d in ["/","/usr","/var","/boot", archivedir, aufs_rw_dir, "/home","/tmp/"]:
  1008.             d = os.path.realpath(d)
  1009.             fs_id = make_fs_id(d)
  1010.             st = os.statvfs(d)
  1011.             free = st[statvfs.F_BAVAIL]*st[statvfs.F_FRSIZE]
  1012.             if fs_id in mnt_map:
  1013.                 logging.debug("Dir %s mounted on %s" % (d,mnt_map[fs_id]))
  1014.                 fs_free[d] = fs_free[mnt_map[fs_id]]
  1015.             else:
  1016.                 logging.debug("Free space on %s: %s" % (d,free))
  1017.                 mnt_map[fs_id] = d
  1018.                 fs_free[d] = FreeSpace(free)
  1019.         del mnt_map
  1020.         logging.debug("fs_free contains: '%s'" % fs_free)
  1021.  
  1022.         # now calculate the space that is required on /boot
  1023.         # we do this by checking how many linux-image-$ver packages
  1024.         # are installed or going to be installed
  1025.         space_in_boot = 0
  1026.         for pkg in self:
  1027.             # we match against everything that looks like a kernel
  1028.             # and add space check to filter out metapackages
  1029.             if re.match("^linux-(image|image-debug)-[0-9.]*-.*", pkg.name):
  1030.                 if pkg.markedInstall:
  1031.                     logging.debug("%s (new-install) added with %s to boot space" % (pkg.name, KERNEL_INITRD_SIZE))
  1032.                     space_in_boot += KERNEL_INITRD_SIZE
  1033.                 # mvo: jaunty does not create .bak files anymore
  1034.                 #elif (pkg.markedUpgrade or pkg.isInstalled):
  1035.                 #    logging.debug("%s (upgrade|installed) added with %s to boot space" % (pkg.name, KERNEL_INITRD_SIZE))
  1036.                 #    space_in_boot += KERNEL_INITRD_SIZE # creates .bak
  1037.  
  1038.         # we check for various sizes:
  1039.         # archivedir is were we download the debs
  1040.         # /usr is assumed to get *all* of the install space (incorrect,
  1041.         #      but as good as we can do currently + safety buffer
  1042.         # /     has a small safety buffer as well
  1043.         required_for_aufs = 0.0
  1044.         if (hasattr(self, "config") and
  1045.             self.config.getWithDefault("Aufs","Enabled", False)):
  1046.             logging.debug("taking aufs overlay into space calculation")
  1047.             aufs_rw_dir = self.config.get("Aufs","RWDir")
  1048.             # if we use the aufs rw overlay all the space is consumed
  1049.             # the overlay dir
  1050.             for pkg in self:
  1051.                 if pkg.markedUpgrade or pkg.markedInstall:
  1052.                     required_for_aufs += self._depcache.GetCandidateVer(pkg._pkg).Size
  1053.                     
  1054.         # sum up space requirements
  1055.         for (dir, size) in [(archivedir, self.requiredDownload),
  1056.                             # plus 50M safety buffer in /usr
  1057.                             ("/usr", self.additionalRequiredSpace),
  1058.                             ("/usr", 50*1024*1024),
  1059.                             ("/boot", space_in_boot), 
  1060.                             ("/tmp", 5*1024*1024),   # /tmp for dkms LP: #427035
  1061.                             ("/", 10*1024*1024),     # small safety buffer /
  1062.                             (aufs_rw_dir, required_for_aufs),
  1063.                            ]:
  1064.             dir = os.path.realpath(dir)
  1065.             logging.debug("dir '%s' needs '%s' of '%s' (%f)" % (dir, size, fs_free[dir], fs_free[dir].free))
  1066.             fs_free[dir].free -= size
  1067.             fs_free[dir].need += size
  1068.  
  1069.         # check for space required violations
  1070.         required_list = {}
  1071.         for dir in fs_free:
  1072.             if fs_free[dir].free < 0:
  1073.                 free_at_least = apt_pkg.SizeToStr(float(abs(fs_free[dir].free)+1))
  1074.                 # make_fs_id ensures we only get stuff on the same
  1075.                 # mountpoint, so we report the requirements only once
  1076.                 # per mountpoint
  1077.                 required_list[make_fs_id(dir)] = FreeSpaceRequired(apt_pkg.SizeToStr(fs_free[dir].need), make_fs_id(dir), free_at_least)
  1078.         # raise exception if free space check fails
  1079.         if len(required_list) > 0:
  1080.             logging.error("Not enough free space: %s" % [str(i) for i in required_list])
  1081.             raise NotEnoughFreeSpaceError(required_list.values())
  1082.         return True
  1083.  
  1084.  
  1085.  
  1086. if __name__ == "__main__":
  1087.     import DistUpgradeConfigParser
  1088.         import DistUpgradeView
  1089.         print "foo"
  1090.     c = MyCache(DistUpgradeConfigParser.DistUpgradeConfig("."),
  1091.                     DistUpgradeView.DistUpgradeView(), None)
  1092.         #c.checkForNvidia()
  1093.         #print c._identifyObsoleteKernels()
  1094.         print c.checkFreeSpace()
  1095.         sys.exit()
  1096.     c.clear()
  1097.         c.create_snapshot()
  1098.         c.installedTasks
  1099.         c.installTasks(["ubuntu-desktop"])
  1100.         print c.getChanges()
  1101.         c.restore_snapshot()
  1102.